home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt40s1.arc / DEFINEKY.MOD < prev    next >
Text File  |  1987-05-16  |  7KB  |  153 lines
  1. (*----------------------------------------------------------------------*)
  2. (*            Get_Key_Section --- Get section/offset of function key    *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. PROCEDURE Get_Key_Section(     Key_Name   : AnyStr;
  6.                            VAR Key_Offset : INTEGER;
  7.                            VAR Key_Number : INTEGER;
  8.                            VAR Section_No : INTEGER );
  9.  
  10. (*----------------------------------------------------------------------*)
  11. (*                                                                      *)
  12. (*     Procedure:  Get_Key_Section                                      *)
  13. (*                                                                      *)
  14. (*     Purpose:    Get section/offset for function/keypad key           *)
  15. (*                                                                      *)
  16. (*     Calling Sequence:                                                *)
  17. (*                                                                      *)
  18. (*        Get_Key_Section(     Key_Name   : AnyStr;                     *)
  19. (*                         VAR Key_Offset : INTEGER;                    *)
  20. (*                         VAR Key_Number : INTEGER;                    *)
  21. (*                         VAR Section_No : INTEGER  );                 *)
  22. (*                                                                      *)
  23. (*           Key_Name   --- Name of key                                 *)
  24. (*           Key_Offset --- Offset of key within section                *)
  25. (*           Key_Number --- Scan code of key                            *)
  26. (*           Section_No --- Section number of key                       *)
  27. (*                                                                      *)
  28. (*----------------------------------------------------------------------*)
  29.  
  30. VAR
  31.    I: INTEGER;
  32.    J: INTEGER;
  33.  
  34. BEGIN (* Get_Key_Section *)
  35.                                    (* Evict blanks from key name *)
  36.    I := POS( ' ' , Key_Name );
  37.  
  38.    WHILE ( I > 0 ) DO
  39.       BEGIN
  40.          DELETE( Key_Name, I, 1 );
  41.          I := POS( ' ' , Key_Name );
  42.       END;
  43.  
  44.    Key_Name := UpperCase( Key_Name );
  45.  
  46.                                    (* Get section number of key.   *)
  47.                                    (* Check for miscellaneous guys *)
  48.                                    (* immediately.                 *)
  49.    FOR J := 1 TO No_Misc_Keys DO
  50.       IF ( Key_Name = Key_Definitions[Misc_Keys[J]].Name ) THEN
  51.          BEGIN
  52.             Section_No := 9;
  53.             Key_Number := Misc_Keys[J];
  54.             Key_Offset := Misc_Keys[J];
  55.             EXIT;
  56.          END;
  57.                                    (* Not a miscellaneous key --   *)
  58.                                    (* try others.                  *)
  59.    I          := 2;
  60.    Key_Name   := Key_Name + '   ';
  61.    Section_No := POS( Key_Name[1] , 'FSCAK  N' );
  62.  
  63.    IF ( Section_No = 6 ) THEN
  64.       Section_No := 0
  65.    ELSE IF ( Key_Name[2] = 'K' ) THEN
  66.       BEGIN
  67.          IF ( Section_No = 3 ) THEN
  68.             Section_No := 7
  69.          ELSE IF ( Section_No = 4 ) THEN
  70.             Section_No := 6;
  71.          I := 3;
  72.       END;
  73.                                    (* Get key number if section number OK *)
  74.    Key_Offset     := 0;
  75.    Key_Number     := -1;
  76.  
  77.    IF ( Section_No > 0 ) THEN
  78.       CASE Key_Name[I] OF
  79.          '0'..'9': WHILE( Key_Name[I] IN ['0'..'9'] ) DO
  80.                       BEGIN
  81.                          Key_Offset := Key_Offset * 10 + ORD(Key_Name[I]) - ORD('0');
  82.                          I          := SUCC( I );
  83.                       END;
  84.          '.'     : Key_Offset := 10;
  85.          '-'     : Key_Offset := 11;
  86.          '+'     : Key_Offset := 12;
  87.          ELSE;
  88.       END (* CASE *)
  89.    ELSE
  90.       EXIT;
  91.                                    (* Can't have offset > 12 )
  92.    IF ( Key_Offset > 12 ) THEN
  93.       EXIT;
  94.                                    (* 0 not allowed in function   *)
  95.                                    (* keys -- OK for top ALT keys *)
  96.                                    (* and keypad.                 *)
  97.    IF ( Key_Offset <= 0 ) THEN
  98.       IF ( Section_No < 5 ) THEN
  99.          EXIT;
  100.  
  101.    CASE Section_No OF
  102.       1..4  : Key_Number  := Key_Offset + Funk_Bases[ Section_No ];
  103.       5     : Key_Number  := Keypad_Nos[ Key_Offset ] + 70;
  104.       6     : Key_Number  := Keypad_Nos[ Key_Offset ] + 173;
  105.       7     : Key_Number  := Ctrl_Keys[ Key_Offset ];
  106.       8     : Key_Number  := Number_Nos[ Key_Offset ] + 119;
  107.    END (* CASE *);
  108.  
  109. END   (* Get_Key_Section *);
  110.  
  111. (*----------------------------------------------------------------------*)
  112. (*            Define_Key --- Define a function/keypad key               *)
  113. (*----------------------------------------------------------------------*)
  114.  
  115. PROCEDURE Define_Key( Key_Name : AnyStr;
  116.                       Key_Text : AnyStr  );
  117.  
  118. (*----------------------------------------------------------------------*)
  119. (*                                                                      *)
  120. (*     Procedure:  Define_Key                                           *)
  121. (*                                                                      *)
  122. (*     Purpose:    Defines a function/keypad key string                 *)
  123. (*                                                                      *)
  124. (*     Calling Sequence:                                                *)
  125. (*                                                                      *)
  126. (*        Define_Key( Key_Name : AnyStr;                                *)
  127. (*                    Key_Text : AnyStr  );                             *)
  128. (*                                                                      *)
  129. (*           Key_Name --- Name of key to define                         *)
  130. (*           Key_Text --- Text of key to be defined                     *)
  131. (*                                                                      *)
  132. (*----------------------------------------------------------------------*)
  133.  
  134. VAR
  135.    Section_No : INTEGER;
  136.    Key_Offset : INTEGER;
  137.    Key_Number : INTEGER;
  138.  
  139. BEGIN (* Define_Key *)
  140.  
  141.    Get_Key_Section( Key_Name, Key_Offset, Key_Number, Section_No );
  142.  
  143.                                    (* Insert key text *)
  144.  
  145.    IF ( Key_Number >= 0 ) THEN
  146.       WITH Key_Definitions[Key_Number] DO
  147.          BEGIN
  148.             IF ( Def = NIL ) THEN
  149.                NEW( Def );
  150.             Def^ := Read_Ctrls( Key_Text );
  151.          END;
  152.  
  153. END   (* Define_Key *);